011732: Saves R2 into the register dump area at 000620+ — this is part of the trap_handler (011716) which saves all registers (R0-R5, SP, stacked PC) to the dump area at 000620 for later error reporting and the "ERROR BEFORE THIS LOC." message.
012440: This is the `get_char` subroutine at 012422; the instruction at 012440 (`BEQ 012460`) checks whether the character just read from the DL11#1 RBUF (via the preceding `MOVB (R0)+,R5` and validation logic) is a null byte (end-of-input), and if
013270: Calls the output stub at 077134 — this is part of a sequence that prints a prompt string (likely "ENTER PASSWORD" or similar) via print_string, then calls the stub which handles final output formatting before returning to the caller.
013622: At address 013622, the `JSR R7,@#037462` instruction calls the unknown subroutine at 037462 with R0=000260, which is part of a sequence of calls (013616-013652) that check hardware configuration parameters (likely magazine or head status) a
013702: Calls subroutine at 037462 (the "unknown data processing" routine with 25 callers) with R0 = 000217 — this is part of a prompt-and-check sequence where the firmware reads operator input (likely a menu selection or parameter entry) and store
014076: This is a JSR to print_string (012214) with R0 loaded with #000323, which likely points to a prompt string such as "ENTER PASSWORD" or "ENTER STEP NUMBER" — the surrounding code validates input via get_char and updates workspace at 000614.
014416: Compares the character in R0 (received from the operator console via `get_char` at 014404) against octal 332 (decimal 218, which is 'Z' in ASCII) to validate that the input falls within the range '0' (octal 300) through 'Z' (octal 332), as
014610: Loads R2 from global address 001014 — this is the entry point of a warm-start or initialization routine (stack pointer set to 014610 at 011752), loading a configuration value (likely board count or step number) before calling subroutines to
014744: This loads R0 with address 010702, which points to a string (likely "ENTER SYSTEM ID" or similar) that will be printed via print_string at the branch target 015004 — it is part of a menu-dispatch block that selects different prompts based o
015212: Unconditional branch (BR) to address 015076, continuing a dispatch loop after storing the stack pointer (SP) into global address 000534 (likely saving the current machine state or stack context for a warm-start or register-dump path).
015256: Compares the byte in R0 (a character just read from the console via get_char) against octal 256 (decimal 174, the ASCII period '.' character) — this is part of the input validation logic in the prompt-and-check subsystem, checking if the op
015272: Compares the byte at global address 010155 (a stored operator-input character or flag) against the character in R0 (just read from the console), checking for a match to validate a repeated or confirmed input entry during a prompt-and-check
015332: Loads R2 with the constant 1 — this is part of a validation/conversion routine (015332-015404) that converts a numeric value to ASCII for display, where R2 holds the digit to be converted (starting with 1) before checking against a stored v
016216: Branch if equal (BEQ) to address 016222, continuing a conditional path after a TST R2 at 016220, likely part of a bit-manipulation routine that sets or clears a flag in a machine-configuration data structure based on a computed bit position
016310: Compares the byte in R0 against octal 256 (decimal 174, the ASCII character '®' or a control code) — this is part of a command dispatch routine (016310) that checks if the operator entered a specific response (likely "N" for "NO" or a rejec
016610: The `ROR R1` at 016610 is part of a bit-manipulation loop that rotates R1 to test successive bits; the subsequent `CMP R1,@#001016` and `BLT 016566` control a loop that iterates through configuration bits, likely related to machine paramete
017232: Compares R1 (a value derived from a byte at offset +1748 from a machine-configuration pointer at 000604) with R2 (likely a step or offset count) to check if the current head/subroutine position is within valid bounds, as part of a machine-p
020574: Unconditional jump (JMP) to address 020020, redirecting control flow after comparing the byte at global 001164 against octal 254 (',') — likely a dispatch to a different menu or configuration routine based on operator input.
021024: The `JSR R7,@#041304` at 021024 calls the `prompt_and_check` subroutine to print a prompt and read/validate user input, likely for a menu selection or parameter entry in the executive firmware's operator interface.
021166: This is a JSR to init_hardware (041074), which zeroes workspace, sets interrupt vectors, and initializes both DL11 UARTs — called during a warm-start or reinitialization path after configuration changes.
022310: Stores the value 1 (from R2) into global address 001016, which is likely a flag or counter (possibly a "board count" or "step number" variable) after checking for a specific operator input character (octal 302, which is 'B' in ASCII) at 022
024102: The `JSR R7,@#036510` at 024102 calls a subroutine that performs data processing or table-building, likely constructing or updating machine parameters (e.g., coordinate offsets or step data) using R3 as a pointer into a configuration table 
024276: The three consecutive `SXT R2` instructions at 024276-024302 sign-extend R2 (which holds a value from `@#001016`) three times, effectively propagating the sign bit through all 16 bits — this is a common PDP-11 idiom to convert a signed 16-b
024616: The `MOV @#000604,R0` at 024616 loads R0 with a pointer from address 000604, which is a base pointer into a hardware configuration table; this is followed by indexed loads to retrieve machine-specific parameters (e.g., magazine counts or he
026532: The `JSR R7,@#036324` at 026532 calls a subroutine at 036324 — this is part of a data-processing or conversion routine that operates on values related to the machine's configuration (likely involving the "MAX MEM" or "ENTER STEP NUMBER" pro
026544: The `MOV #010123,R0` at 026544 loads R0 with address 010123, which is then used in a subsequent `JSR R7,@#012214` (print_string) — this prints a string from the data region, likely an error message or prompt such as "ERROR" or "ERASED", bas
026626: The `BEQ 026736` at 026626 branches if the previous comparison or test (likely at 026622-026624) indicates equality, jumping to address 026736 — this is a conditional branch in a validation or menu-dispatch routine, likely taken when a user
027466: Calls `prompt_and_check` (041304) — this is a subroutine that prints a prompt and reads/validates input, likely for a menu selection or parameter entry in the operator console interaction.
027476: Calls `print_string` (012214) with R0 pointing to address 011010 — this prints a prompt string (likely "ENTER PASSWORD" or similar) to the operator console via the DL11 UART.
030136: BIS #000200,+6(R2) at 030136 — sets bit 0200 (octal) in the byte at offset +6 from the address in R2, enabling or marking a flag (possibly "machine active" or "head enabled") after a prior BPL test at 030124 determined the condition was pos
030676: The `BEQ 030722` at 030676 checks if the result of the subroutine call at 037462 (with R0 pointing to #010724) is zero, branching to a different code path — this is part of a menu or configuration routine that tests a condition (e.g., user
031016: The `CMPB #000320,R0` at 031016 compares the byte in R0 (likely a character from get_char) with octal 320 (decimal 208, which is 'Ð' or a control character) — this is part of a command parser that checks for a specific input (possibly a fun
031060: The `CMPB #000323,R0` at 031060 compares the byte in R0 with octal 323 (decimal 211, which is 'Ó' or a control character) — this is part of a user-input validation loop that checks for a specific character (possibly 'S' for "START" or a men
031374: The `BEQ 031262` at 031374 checks if a previous comparison or arithmetic result (from the `.WORD 005701` at 031372) is zero, branching to an earlier address — this is part of a conditional jump in a subroutine that handles machine parameter
032324: The `CMPB #000215,R0` at 032324 compares the byte in R0 with octal 215 (carriage return, CR) — this is part of an input-processing routine that checks if the user pressed Enter (CR) to branch to address 032120, or checks for other special c
032544: BPL 032534 at 032544 — branches back to 032534 if R0 is positive (non-negative), continuing a loop that decrements R0 by 4 and calls subroutine 032744 (head-type checking) for each entry in a table, iterating through all heads or shuttles u
033014: CMP R3,+1810(R0) at 033014 — compares the value in R3 (loaded from @#001132 plus 0144, a shuttle/head position pointer) against the value at offset +1810 from the base address in R0 (likely a stored position limit or target), and branches i
033162: BEQ 033214 at 033162 — branches to 033214 if the zero flag is set (result of prior subroutine call at 037110 was zero), indicating a condition was met (likely a valid character or state), where it then stores the byte from R0 into a buffer
033404: RTS R7 at 033404 — returns from subroutine, completing a routine that called prompt_and_check (033360), printed a string at 010560 (likely "ENTER STEP NUMBER" or similar), and called subroutines at 033062 and 032550 to validate and process
033406: Loads R0 with address 010577, which points to a prompt string (likely "ENTER STEP NUMBER" or similar) — this prepares to print that prompt via the print_string subroutine at 033370, as part of a step-number entry sequence.
034004: MOV @#000604,R0 at 034004 — loads R0 with the value stored at address 000604 (a pointer to a machine configuration or head data block), then uses it to fetch a value at offset +1810(R0) into R1 (016001 at 034010), part of a routine that pro
034432: JSR R7,@#037360 at 034432 — calls subroutine at 037360 (an unknown data-processing routine with 25 callers) when the character in R0 matches #000304 (octal 304, which is 'D' in DEC-ASCII), part of a menu dispatch that handles different keyp
034772: Loads R3 from address 001132 (a workspace variable) — retrieves a counter or pointer value used in a loop that processes machine parameters or display data.
035676: JMP @#035560 at 035676 — jumps unconditionally to address 035560 (likely a loop or dispatch point for machine-link communication or coordinate processing), after testing bit 0 of the flag at 001022 (BIT #000001,@#001022 at 035662) and findi
037530: Calls `print_string` (012214) to output the prompt string at 010042, which is likely "ENTER PASSWORD" or a similar operator prompt, as part of a password validation routine.
041136: Initializes the trap handler's register dump area by storing 007662 (the address of the dump buffer) into location 000612, which is used by the trap handler to save registers during bus error or illegal instruction recovery.
041172: Returns from subroutine (`RTS R7`) — this is the end of the `init_hardware` subroutine (041074), which has just completed initializing interrupt vectors, UARTs, and workspace.
042632: Loads byte from memory at offset +1746(R0) into R2, then masks to low byte — part of a routine that reads a machine configuration byte (likely head or magazine status) for comparison in the dispatch logic.
045256: Jumps to address 072132 — this is a dispatch table entry that handles a specific menu option or machine state, with R1 set to 000034 (octal 34) as a parameter for the dispatch routine.
047056: `MOV R0,R1` — copies the base pointer R0 into R1, preparing to compute an indexed address by adding the value at 000562 (a configuration word or offset table base) to R1 for subsequent data access.
047760: Conditional branch (`BEQ 047730`) that checks if R5 equals 002400, branching to set up machine configuration bits (BIS instructions) for a specific head or shuttle mode.
050142: This compares R5 against #002400, checking if the current machine configuration corresponds to a specific head or shuttle mode (likely a 24-magazine or non-multi-mod DIP configuration), branching to set appropriate control bits.
050320: Compares R5 against 000300 to test for a specific machine configuration or head type, branching to handle that case in the dispatch logic.
050332: Branches if equal to address 050470 — this conditional branch follows a `BIT #001000,R3` test, checking if a specific bit (likely indicating a head or magazine configuration) is clear, and if so, skips to an alternative processing path.
050640: Adds R2 to a memory location offset from R1 (address +2034), likely updating a machine parameter such as a step count, offset value, or coordinate accumulator.
051172: Jumps to subroutine at 071052 — this call is made after setting a status bit at +2964(R0) when a comparison of magazine/shuttle counts at +1780(R0) and +1778(R0) matches, indicating successful validation of machine configuration.
051226: This loads R3 with a value from memory offset +1780(R0), which is part of a comparison routine that checks magazine or shuttle counts against stored parameters, likely validating machine configuration before proceeding with a placement sequ
051476: `CMPB #000101,(R3)` — compares the byte at address R3 with octal 101 (ASCII 'A'), checking if the first character of a string (likely a machine mode or head identifier) is 'A' to branch accordingly.
052322: Moves the value at +2292(R0) to +2260(R0) — this copies a "current step" or "sequence position" counter to a backup location, part of a routine that manages step sequencing for the placement head.
052544: Masks off the upper bits of R5 (`BIC #170377,R5`) to isolate the low-order machine-type identifier, then compares it against 003000 to determine if the current machine configuration matches a specific head or shuttle type.
053004: BEQ at 053004 branches to 053152 if the bit test at 052776 (BIT #000003,@+3250(R0)) is zero — this checks a status flag in the machine-link or head-status word, likely testing for a specific head or shuttle state before proceeding with a co
053156: Loads R1 with #005000 (octal 5000) — this sets up a parameter for a subsequent bit-test operation that checks a machine status flag, likely related to magazine or head configuration validation.
053622: This loads R5 with #000004 and then JSRs to subroutine 061450, which is a data processing routine called when the operator has entered an invalid response (not Q, R, S, or T) to a prompt, decrementing the retry counter.
053636: Loads R5 with #000004 and jumps to subroutine 061404 — this is called when the operator has entered a valid response (Q, R, S, or T) to a prompt, setting up a retry counter or parameter for the validation routine.
054514: Branches if plus to address 054610 — this conditional branch follows a previous operation that tests a status flag, likely checking if a machine operation completed successfully before proceeding to the next step in the sequence.
054726: MOVB #000330,+2228(R0) at 054726 stores the octal value 330 (decimal 216) into a workspace byte offset from R0 — this sets a machine parameter or error code, likely related to a "MACH & TAPE TYPE DON'T MATCH" condition, as the preceding com
055070: CMPB #000116,R3 at 055070 compares register R3 (a character from input) against ASCII 'N' (octal 116) — this is part of a menu dispatch that checks for valid responses ('N', 'Q', 'S', 'P') to a prompt such as "I-M CONV REQ? / ENT I-IN, M-ME
056662: This is a JSR to subroutine 061324, which is a data processing routine called with R1=#000200 and R5=#000004, likely validating or processing a machine parameter after decrementing a counter and clearing configuration bits.
061732: ADD R2,R3 at 061732 adds an offset (R2) to a position value (R3) and then compares against a boundary at 001032 — this is part of a coordinate-clamping or wrap-around algorithm for head/shuttle positioning, likely adjusting a step or offset
062112: BIC #177700,R1 at 062112 masks off the high 9 bits of R1, keeping only the low 7 bits (0-177 octal) — this extracts a 7-bit ASCII character or index value from a byte loaded at 062110 (MOVB (R3),R1), preparing it for use as an offset into a
063016: tests the high-order bit of the machine status word at R0+3250 to conditionally handle a critical state.  Sample 2 (064040): Instruction: 001412  BEQ 064066 This is a branch instruction that jumps if the zero condition code is set. It comes
064040: branches if the 7th bit of register R5 (a status flag) is not set, otherwise continues with a state update.  Sample 3 (066670): Instruction: 000412  BR 066716 This is an unconditional branch to 066716. The surrounding code has:  066660: 100
064114: This clears bits 170377 (all but the low 7 bits) in R5 using BIC, extracting a machine-type identifier from a word loaded from the hardware device table, which is then compared against #003000 and #004400 to determine the machine configurat
065212: JSR R7,@#070022 at 065212 calls a subroutine at address 070022 — this is invoked when R4 (a head or shuttle index) is non-zero (BEQ at 065210 fails), and the result (R1) is added to a position accumulator at +2034(R0), suggesting this adjus
066364: CMP #000003,R4 at 066364 compares R4 (a mode or index value, masked to low 3 bits at 066360) against the constant 3 — this is a bounds check or dispatch for a state machine (likely selecting among 4 possible head/shuttle modes or magazine c
066670: unconditionally branches to the right-rotate instruction at 066716, skipping the subsequent ADD instruction.  Sample 4 (067450): Instruction: 001044  BNE 067562 This is a branch if not equal to 067562. It comes after: 067442: 126327  CMPB +
067450: branches if the byte at R3+7 is not 'Z' (0o132), otherwise continues with string processing.  Sample 5 (070520): Instruction: 020104  CMP R1,R4 This is a comparison between R1 and R4. It is repeated in a loop-like structure:  070506: 020104
070520: compares R1 and R4 to determine if R1 is greater than or equal to R4, then subtracts R4 if true, in a division loop.  Sample 6 (072070): Instruction: 036064  BIT +23630(R0),+28784(R4) This is a BIT instruction that tests bits in the word at
072070: tests the bits in a word (at R0+23630) against another word (at R4+28784) to set condition codes for a multiplication routine.  Sample 7 (072374): Instruction: 004737  JSR R7,@#071254 This is a subroutine call. The destination is at address
073430: branches if a prior comparison was greater than, to a specific location in the menu handling code.  Sample 9 (073556): Instruction: 000404  BR 073570 This is an unconditional branch to 073570. The surrounding code has:  073546: 032770  BIT 
073532: BR 073536 at 073532 is an unconditional branch that skips over the next instruction (BR 073560) — this is a simple control-flow redirection within a decision tree, likely part of a menu or mode-selection routine that tests bits in a status
074154: branches to 073744 if bit 3 (or bit 2) of the state word at R0+3282 is set, otherwise continues.  Specifically, it branches if bit 3 is set, or if bit 3 is not set but bit 2 is set.  However, the instruction at 074154 is only taken if bit 3
